Micron Document
<!DOCTYPE html>
<html class="client-nojs vector-feature-night-mode-disabled vector-feature-language-in-header-enabled vector-feature-language-in-main-page-header-disabled vector-feature-page-tools-pinned-disabled vector-feature-toc-pinned-clientpref-1 vector-feature-main-menu-pinned-disabled vector-feature-limited-width-clientpref-1 vector-feature-limited-width-content-enabled vector-feature-custom-font-size-clientpref-1 vector-feature-appearance-pinned-clientpref-1 vector-sticky-header-enabled" lang="en" dir="ltr"><head>
<meta charset="UTF-8">
<title>Quine (computing)</title>
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<link rel="canonical" href="https://en.wikipedia.org/wiki/Quine_(computing)"> <link href="./mw/ext.cite.styles.css" rel="stylesheet" type="text/css">
<link href="./mw/ext.pygments.css" rel="stylesheet" type="text/css">
<link href="./mw/skins.vector.icons.css" rel="stylesheet" type="text/css">
<link href="./mw/skins.vector.search.codex.styles.css" rel="stylesheet" type="text/css">
<link href="./mw/skins.vector.styles.css" rel="stylesheet" type="text/css">
<link href="./mw/user.styles.css" rel="stylesheet" type="text/css">
<meta name="ResourceLoaderDynamicStyles" content="">
<link rel="stylesheet" type="text/css" href="./mw/site.styles.css">
<link rel="stylesheet" type="text/css" href="./mw/noscript.css">
<link rel="stylesheet" type="text/css" href="./footer.css">
<link rel="stylesheet" type="text/css" href="./vector-2022.css">
</head>
<body class="skin--responsive skin-vector skin-vector-search-vue mediawiki ltr sitedir-ltr mw-hide-empty-elt ns-0 ns-subject page-Quine_computing rootpage-Quine_computing skin-vector-2022 action-view">
<div class="mw-page-container">
<div class="mw-page-container-inner">
<div class="mw-content-container">
<main id="content" class="mw-body">
<header class="mw-body-header vector-page-titlebar">
<h1 id="firstHeading" class="firstHeading mw-first-heading">
<span id="openzim-page-title" class="mw-page-title-main"><span class="mw-page-title-main">Quine (computing)</span></span>
</h1>
</header>
<a id="top"></a>
<div id="bodyContent" class="vector-body ve-init-mw-desktopArticleTarget-targetContainer" aria-labelledby="firstHeading" data-mw-ve-target-container="">
<div id="mw-content-text" class="mw-body-content mw-content-ltr" lang="en" dir="ltr"><div class="mw-content-ltr mw-parser-output" lang="en" dir="ltr">

<p>A <b>quine</b> is a <a href="Computer_program" title="Computer program">computer program</a> that takes no input and produces a copy of its own <a href="Source_code" title="Source code">source code</a> as its only output. The standard terms for these programs in the <a href="Computability_theory" title="Computability theory">computability theory</a> and <a href="Computer_science" title="Computer science">computer science</a> literature are "self-replicating programs", "self-reproducing programs", and "self-copying programs".
</p><p>A quine is a <a href="Fixed_point_(mathematics)" title="Fixed point (mathematics)">fixed point</a> of an execution environment, when that environment is viewed as a <a href="Function_(mathematics)" title="Function (mathematics)">function</a> transforming programs into their outputs. Quines are possible in any <a href="Turing_completeness" title="Turing completeness">Turing-complete</a> programming language, as a direct consequence of <a href="Kleene's_recursion_theorem" title="Kleene's recursion theorem">Kleene's recursion theorem</a>. For amusement, programmers sometimes attempt to develop the shortest possible quine in any given <a href="Programming_language" title="Programming language">programming language</a>.
</p>
<meta property="mw:PageProp/toc">
<div class="mw-heading mw-heading2"><h2 id="Name">Name</h2></div>
<p>The name "quine" was coined by <a href="Douglas_Hofstadter" title="Douglas Hofstadter">Douglas Hofstadter</a>, in his popular 1979 science book <i><a href="G%C3%B6del%2C_Escher%2C_Bach" title="Gödel, Escher, Bach">Gödel, Escher, Bach</a></i>, in honor of philosopher <a href="Willard_Van_Orman_Quine" title="Willard Van Orman Quine">Willard Van Orman Quine</a> (1908–2000), who made an extensive study of <a href="Indirect_self-reference" title="Indirect self-reference">indirect self-reference</a>, and in particular for the following paradox-producing expression, known as <a href="Quine's_paradox" title="Quine's paradox">Quine's paradox</a>:
</p>
<blockquote>
<p>"Yields falsehood when preceded by its quotation" yields falsehood when preceded by its quotation.
</p>
</blockquote>
<div class="mw-heading mw-heading2"><h2 id="History">History</h2></div>
<p><a href="John_von_Neumann" title="John von Neumann">John von Neumann</a> theorized about <a href="Von_Neumann_universal_constructor" title="Von Neumann universal constructor">self-reproducing automata</a> in the 1940s. Later, Paul Bratley and Jean Millo's article "Computer Recreations: Self-Reproducing Automata" discussed them in 1972.<sup id="cite_ref-Bratley_Millo_1-0" class="reference"><a href="#cite_note-Bratley_Millo-1"><span class="cite-bracket">[</span>1<span class="cite-bracket">]</span></a></sup>
Bratley first became interested in self-reproducing programs after seeing the first known such program written in <a href="Atlas_Autocode" title="Atlas Autocode">Atlas Autocode</a> at Edinburgh in the 1960s by the <a href="University_of_Edinburgh" title="University of Edinburgh">University of Edinburgh</a> lecturer and researcher Hamish Dewar.
</p><p>The "download source" requirement of the <a href="GNU_Affero_General_Public_License" title="GNU Affero General Public License">GNU Affero General Public License</a> is based on the idea of a quine.<sup id="cite_ref-Stet_and_AGPLV3_2-0" class="reference"><a href="#cite_note-Stet_and_AGPLV3-2"><span class="cite-bracket">[</span>2<span class="cite-bracket">]</span></a></sup>
</p>
<div class="mw-heading mw-heading2"><h2 id="Examples">Examples</h2></div>
<div class="mw-heading mw-heading3"><h3 id="Constructive_quines">Constructive quines</h3></div>
<p>In general, the method used to create a quine in any programming language is to have, within the program, two pieces: (a)&nbsp;<a href="Source_code" title="Source code">code</a> used to do the actual printing and (b)&nbsp;<a href="Data" title="Data">data</a> that represents the textual form of the code. The code functions by using the data to print the code (which makes sense since the data represents the textual form of the code), but it also uses the data, processed in a simple way, to print the textual representation of the data itself.
</p><p>Here are three small examples in Python3:
</p>
<div class="mw-highlight mw-highlight-lang-python3 mw-content-ltr" dir="ltr"><pre><span class="c1"># Example A. chr(39) == "'".</span>
<span class="n">a</span> <span class="o">=</span> <span class="s1">'a = </span><span class="si">{}{}{}</span><span class="s1">; print(a.format(chr(39), a, chr(39)))'</span><span class="p">;</span> <span class="nb">print</span><span class="p">(</span><span class="n">a</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="nb">chr</span><span class="p">(</span><span class="mi">39</span><span class="p">),</span> <span class="n">a</span><span class="p">,</span> <span class="nb">chr</span><span class="p">(</span><span class="mi">39</span><span class="p">)))</span>
</pre></div>
<div class="mw-highlight mw-highlight-lang-python3 mw-content-ltr" dir="ltr"><pre><span class="c1"># Example B. chr(39) == "'".</span>
<span class="n">b</span> <span class="o">=</span> <span class="s1">'b = </span><span class="si">%s%s%s</span><span class="s1">; print(b </span><span class="si">%%</span><span class="s1"> (chr(39), b, chr(39)))'</span><span class="p">;</span> <span class="nb">print</span><span class="p">(</span><span class="n">b</span> <span class="o">%</span> <span class="p">(</span><span class="nb">chr</span><span class="p">(</span><span class="mi">39</span><span class="p">),</span> <span class="n">b</span><span class="p">,</span> <span class="nb">chr</span><span class="p">(</span><span class="mi">39</span><span class="p">)))</span>
</pre></div>
<div class="mw-highlight mw-highlight-lang-python3 mw-content-ltr" dir="ltr"><pre><span class="c1"># Example C. %r will quote automatically.</span>
<span class="n">c</span> <span class="o">=</span> <span class="s1">'c = </span><span class="si">%r</span><span class="s1">; print(c </span><span class="si">%%</span><span class="s1"> c)'</span><span class="p">;</span> <span class="nb">print</span><span class="p">(</span><span class="n">c</span> <span class="o">%</span> <span class="n">c</span><span class="p">)</span>
</pre></div><p>The following <a href="Java_(programming_language)" title="Java (programming language)">Java</a> code demonstrates the basic structure of a quine.
</p><div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">Quine</span>
<span class="p">{</span>
<span class="w"> </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">main</span><span class="p">(</span><span class="n">String</span><span class="o">[]</span><span class="w"> </span><span class="n">args</span><span class="p">)</span>
<span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="kt">char</span><span class="w"> </span><span class="n">q</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">34</span><span class="p">;</span><span class="w"> </span><span class="c1">// Quotation mark character</span>
<span class="w"> </span><span class="n">String</span><span class="o">[]</span><span class="w"> </span><span class="n">l</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="p">{</span><span class="w"> </span><span class="c1">// Array of source code</span>
<span class="w"> </span><span class="s">"public class Quine"</span><span class="p">,</span>
<span class="w"> </span><span class="s">"{"</span><span class="p">,</span>
<span class="w"> </span><span class="s">" public static void main(String[] args)"</span><span class="p">,</span>
<span class="w"> </span><span class="s">" {"</span><span class="p">,</span>
<span class="w"> </span><span class="s">" char q = 34; // Quotation mark character"</span><span class="p">,</span>
<span class="w"> </span><span class="s">" String[] l = { // Array of source code"</span><span class="p">,</span>
<span class="w"> </span><span class="s">" "</span><span class="p">,</span>
<span class="w"> </span><span class="s">" };"</span><span class="p">,</span>
<span class="w"> </span><span class="s">" for (int i = 0; i &lt; 6; i++) // Print opening code"</span><span class="p">,</span>
<span class="w"> </span><span class="s">" System.out.println(l[i]);"</span><span class="p">,</span>
<span class="w"> </span><span class="s">" for (int i = 0; i &lt; l.length; i++) // Print string array"</span><span class="p">,</span>
<span class="w"> </span><span class="s">" System.out.println(l[6] + q + l[i] + q + ',');"</span><span class="p">,</span>
<span class="w"> </span><span class="s">" for (int i = 7; i &lt; l.length; i++) // Print this code"</span><span class="p">,</span>
<span class="w"> </span><span class="s">" System.out.println(l[i]);"</span><span class="p">,</span>
<span class="w"> </span><span class="s">" }"</span><span class="p">,</span>
<span class="w"> </span><span class="s">"}"</span><span class="p">,</span>
<span class="w"> </span><span class="p">};</span>
<span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">0</span><span class="p">;</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">&lt;</span><span class="w"> </span><span class="mi">6</span><span class="p">;</span><span class="w"> </span><span class="n">i</span><span class="o">++</span><span class="p">)</span><span class="w"> </span><span class="c1">// Print opening code</span>
<span class="w"> </span><span class="n">System</span><span class="p">.</span><span class="na">out</span><span class="p">.</span><span class="na">println</span><span class="p">(</span><span class="n">l</span><span class="o">[</span><span class="n">i</span><span class="o">]</span><span class="p">);</span>
<span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">0</span><span class="p">;</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">&lt;</span><span class="w"> </span><span class="n">l</span><span class="p">.</span><span class="na">length</span><span class="p">;</span><span class="w"> </span><span class="n">i</span><span class="o">++</span><span class="p">)</span><span class="w"> </span><span class="c1">// Print string array</span>
<span class="w"> </span><span class="n">System</span><span class="p">.</span><span class="na">out</span><span class="p">.</span><span class="na">println</span><span class="p">(</span><span class="n">l</span><span class="o">[</span><span class="mi">6</span><span class="o">]</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="n">q</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="n">l</span><span class="o">[</span><span class="n">i</span><span class="o">]</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="n">q</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="sc">','</span><span class="p">);</span>
<span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">7</span><span class="p">;</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">&lt;</span><span class="w"> </span><span class="n">l</span><span class="p">.</span><span class="na">length</span><span class="p">;</span><span class="w"> </span><span class="n">i</span><span class="o">++</span><span class="p">)</span><span class="w"> </span><span class="c1">// Print this code</span>
<span class="w"> </span><span class="n">System</span><span class="p">.</span><span class="na">out</span><span class="p">.</span><span class="na">println</span><span class="p">(</span><span class="n">l</span><span class="o">[</span><span class="n">i</span><span class="o">]</span><span class="p">);</span>
<span class="w"> </span><span class="p">}</span>
<span class="p">}</span>
</pre></div>
<p>The source code contains a string array of itself, which is output twice, once inside quotation marks.
</p><p>This code was adapted from an original post from c2.com, where the author, Jason Wilson, posted it as a minimalistic version of a Quine, without Java comments.<sup id="cite_ref-3" class="reference"><a href="#cite_note-3"><span class="cite-bracket">[</span>3<span class="cite-bracket">]</span></a></sup>
</p><p>Thanks to new <a rel="nofollow" class="external text" href="https://openjdk.java.net/jeps/378">text blocks</a> feature in Java 15 (or newer), a more readable and simpler version is possible:<sup id="cite_ref-4" class="reference"><a href="#cite_note-4"><span class="cite-bracket">[</span>4<span class="cite-bracket">]</span></a></sup>
</p>
<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">Quine</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">main</span><span class="p">(</span><span class="n">String</span><span class="o">[]</span><span class="w"> </span><span class="n">args</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="n">textBlockQuotes</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">String</span><span class="p">(</span><span class="k">new</span><span class="w"> </span><span class="kt">char</span><span class="o">[]</span><span class="p">{</span><span class="sc">'"'</span><span class="p">,</span><span class="w"> </span><span class="sc">'"'</span><span class="p">,</span><span class="w"> </span><span class="sc">'"'</span><span class="p">});</span>
<span class="w"> </span><span class="kt">char</span><span class="w"> </span><span class="n">newLine</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">10</span><span class="p">;</span>
<span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="n">source</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s">"""</span>
<span class="s">public class Quine {</span>
<span class="s"> public static void main(String[] args) {</span>
<span class="s"> String textBlockQuotes = new String(new char[]{'"', '"', '"'});</span>
<span class="s"> char newLine = 10;</span>
<span class="s"> String source = %s;</span>
<span class="s"> System.out.print(source.formatted(textBlockQuotes + newLine + source + textBlockQuotes));</span>
<span class="s"> }</span>
<span class="s">}</span>
<span class="s">"""</span><span class="p">;</span>
<span class="w"> </span><span class="n">System</span><span class="p">.</span><span class="na">out</span><span class="p">.</span><span class="na">print</span><span class="p">(</span><span class="n">source</span><span class="p">.</span><span class="na">formatted</span><span class="p">(</span><span class="n">textBlockQuotes</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="n">newLine</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="n">source</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="n">textBlockQuotes</span><span class="p">));</span>
<span class="w"> </span><span class="p">}</span>
<span class="p">}</span>
</pre></div><p>The same idea is used in the following <a href="SQL" title="SQL">SQL</a> quine:</p><div class="mw-highlight mw-highlight-lang-sql mw-content-ltr" dir="ltr"><pre><span class="k">SELECT</span><span class="w"> </span><span class="k">REPLACE</span><span class="p">(</span><span class="k">REPLACE</span><span class="p">(</span><span class="s1">'SELECT REPLACE(REPLACE("$",CHAR(34),CHAR(39)),CHAR(36),"$") AS Quine'</span><span class="p">,</span><span class="nb">CHAR</span><span class="p">(</span><span class="mi">34</span><span class="p">),</span><span class="nb">CHAR</span><span class="p">(</span><span class="mi">39</span><span class="p">)),</span><span class="nb">CHAR</span><span class="p">(</span><span class="mi">36</span><span class="p">),</span><span class="s1">'SELECT REPLACE(REPLACE("$",CHAR(34),CHAR(39)),CHAR(36),"$") AS Quine'</span><span class="p">)</span><span class="w"> </span><span class="k">AS</span><span class="w"> </span><span class="n">Quine</span>
</pre></div>
<div class="mw-heading mw-heading3"><h3 id="Eval_quines">Eval quines</h3></div>
<p>Some programming languages have the ability to evaluate a string as a program. Quines can take advantage of this feature. For example, this <a href="Ruby_(programming_language)" title="Ruby (programming language)">Ruby</a> quine:
</p>
<div class="mw-highlight mw-highlight-lang-ruby mw-content-ltr" dir="ltr"><pre><span class="nb">eval</span><span class="w"> </span><span class="n">s</span><span class="o">=</span><span class="s2">"print 'eval s=';p s"</span>
</pre></div>
<p><a href="Lua_(programming_language)" class="mw-redirect" title="Lua (programming language)">Lua</a> can do:
</p>
<div class="mw-highlight mw-highlight-lang-lua mw-content-ltr" dir="ltr"><pre><span class="nv">s</span><span class="o">=</span><span class="s2">"print(string.format('s=%c%s%c; load(s)()',34,s,34))"</span><span class="p">;</span><span class="w"> </span><span class="nb">load</span><span class="p">(</span><span class="nv">s</span><span class="p">)()</span>
</pre></div>
<p>In Python 3.8:
</p>
<div class="mw-highlight mw-highlight-lang-python3 mw-content-ltr" dir="ltr"><pre><span class="n">exec</span><span class="p">(</span><span class="n">s</span><span class="o">:=</span><span class="s1">'print("exec(s:=</span><span class="si">%r</span><span class="s1">)"</span><span class="si">%s</span><span class="s1">)'</span><span class="p">)</span>
</pre></div>
<div class="mw-heading mw-heading3"><h3 id="&quot;Cheating&quot;_quines">"Cheating" quines</h3></div>
<div class="mw-heading mw-heading4"><h4 id="Self-evaluation">Self-evaluation</h4></div>
<p>In many functional languages, including <a href="Scheme_(programming_language)" title="Scheme (programming language)">Scheme</a> and other <a href="Lisp_(programming_language)" title="Lisp (programming language)">Lisps</a>, and interactive languages such as <a href="APL_(programming_language)" title="APL (programming language)">APL</a>, numbers are self-evaluating. In <a href="TI-BASIC" title="TI-BASIC">TI-BASIC</a>, if the last line of a program returns a value, the returned value is displayed on the screen. Therefore, in such languages a program consisting of only a single digit results in a 1-byte quine. Since such code does not <i>construct</i> itself, this is often considered cheating.
</p>
<div class="mw-highlight mw-highlight-lang-basic mw-content-ltr" dir="ltr"><pre><span class="nl">1</span>
</pre></div>
<div class="mw-heading mw-heading4"><h4 id="Empty_quines">Empty quines</h4></div>
<p>In some languages, particularly <a href="Scripting_language" title="Scripting language">scripting languages</a> but also <a href="C_(programming_language)" title="C (programming language)">C</a>, an empty source file is a fixed point of the language, being a valid program that produces no output.<sup id="cite_ref-5" class="reference"><a href="#cite_note-5"><span class="cite-bracket">[</span>a<span class="cite-bracket">]</span></a></sup> Such an empty program, submitted as "the world's smallest self reproducing program", once won the "worst abuse of the rules" prize in the <a href="International_Obfuscated_C_Code_Contest" title="International Obfuscated C Code Contest">International Obfuscated C Code Contest</a>.<sup id="cite_ref-6" class="reference"><a href="#cite_note-6"><span class="cite-bracket">[</span>5<span class="cite-bracket">]</span></a></sup> The program was not actually compiled, but used <code>cp</code> to copy the file into another file, which could be executed to print nothing.<sup id="cite_ref-7" class="reference"><a href="#cite_note-7"><span class="cite-bracket">[</span>6<span class="cite-bracket">]</span></a></sup>
</p>
<div class="mw-heading mw-heading4"><h4 id="Source_code_inspection">Source code inspection</h4></div>
<p>Quines, per definition, cannot receive <i>any</i> form of input, including reading a file, which means a quine is considered to be "cheating" if it looks at its own source code. The following <a href="Unix_shell" title="Unix shell">shell</a> script is not a quine:
</p>
<div class="mw-highlight mw-highlight-lang-bash mw-content-ltr" dir="ltr"><pre><span class="ch">#!/bin/sh</span>
<span class="c1"># Invalid quine.</span>
<span class="c1"># Reading the executed file from disk is cheating.</span>
cat<span class="w"> </span><span class="nv">$0</span>
</pre></div>
<p>A shorter variant, exploiting the behaviour of <a href="Shebang_(Unix)" title="Shebang (Unix)">shebang</a> directives:
</p>
<div class="mw-highlight mw-highlight-lang-bash mw-content-ltr" dir="ltr"><pre><span class="ch">#!/bin/cat</span>
</pre></div>
<p>Other questionable techniques include making use of compiler messages; for example, in the <a href="GW-BASIC" title="GW-BASIC">GW-BASIC</a> environment, entering "Syntax Error" will cause the interpreter to respond with "Syntax Error".
</p><p>Quine code can also be outputted visually, for example it's used to visualize the neutral zone in <a href="Yars'_Revenge" title="Yars' Revenge">Yars' Revenge</a>, along with <a href="Syntactic_sugar#Syntactic_saccharin" title="Syntactic sugar">syntactic saccharin</a>, to obfuscate the source code.
</p>
<div class="mw-heading mw-heading2"><h2 id="Ouroboros_programs">Ouroboros programs</h2></div>
<p>The quine concept can be extended to multiple levels of recursion, giving rise to "<a href="Ouroboros" title="Ouroboros">ouroboros</a> programs", or quine-relays. This should not be confused with <a href="#Multiquines">multiquines</a>.
</p>
<div class="mw-heading mw-heading3"><h3 id="Example">Example</h3></div>
<p>This Java program outputs the source for a C++ program that outputs the original Java code.
</p>
<div style="width: 49%; overflow: auto; float: right; padding-left: 1%;">
<div class="mw-highlight mw-highlight-lang-cpp mw-content-ltr" dir="ltr"><pre><span class="cp">#include</span><span class="w"> </span><span class="cpf">&lt;iostream&gt;</span>
<span class="cp">#include</span><span class="w"> </span><span class="cpf">&lt;string&gt;</span>
<span class="k">using</span><span class="w"> </span><span class="k">namespace</span><span class="w"> </span><span class="nn">std</span><span class="p">;</span>

<span class="kt">int</span><span class="w"> </span><span class="nf">main</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">argc</span><span class="p">,</span><span class="w"> </span><span class="kt">char</span><span class="o">*</span><span class="w"> </span><span class="n">argv</span><span class="p">[])</span>
<span class="p">{</span>
<span class="w"> </span><span class="kt">char</span><span class="w"> </span><span class="n">q</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">34</span><span class="p">;</span>
<span class="w"> </span><span class="n">string</span><span class="w"> </span><span class="n">l</span><span class="p">[]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="s">" "</span><span class="p">,</span>
<span class="w"> </span><span class="s">"=============&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt; C++ Code &gt;&gt;&gt;&gt;&gt;&gt;&gt;&gt;============="</span><span class="p">,</span>
<span class="w"> </span><span class="s">"#include &lt;iostream&gt;"</span><span class="p">,</span>
<span class="w"> </span><span class="s">"#include &lt;string&gt;"</span><span class="p">,</span>
<span class="w"> </span><span class="s">"using namespace std;"</span><span class="p">,</span>
<span class="w"> </span><span class="s">""</span><span class="p">,</span>
<span class="w"> </span><span class="s">"int main(int argc, char* argv[])"</span><span class="p">,</span>
<span class="w"> </span><span class="s">"{"</span><span class="p">,</span>
<span class="w"> </span><span class="s">" char q = 34;"</span><span class="p">,</span>
<span class="w"> </span><span class="s">" string l[] = {"</span><span class="p">,</span>
<span class="w"> </span><span class="s">" };"</span><span class="p">,</span>
<span class="w"> </span><span class="s">" for(int i = 20; i &lt;= 25; i++)"</span><span class="p">,</span>
<span class="w"> </span><span class="s">" cout &lt;&lt; l[i] &lt;&lt; endl;"</span><span class="p">,</span>
<span class="w"> </span><span class="s">" for(int i = 0; i &lt;= 34; i++)"</span><span class="p">,</span>
<span class="w"> </span><span class="s">" cout &lt;&lt; l[0] + q + l[i] + q + ',' &lt;&lt; endl;"</span><span class="p">,</span>
<span class="w"> </span><span class="s">" for(int i = 26; i &lt;= 34; i++)"</span><span class="p">,</span>
<span class="w"> </span><span class="s">" cout &lt;&lt; l[i] &lt;&lt; endl;"</span><span class="p">,</span>
<span class="w"> </span><span class="s">" return 0;"</span><span class="p">,</span>
<span class="w"> </span><span class="s">"}"</span><span class="p">,</span>
<span class="w"> </span><span class="s">"=============&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt; Java Code &gt;&gt;&gt;&gt;&gt;&gt;&gt;&gt;============="</span><span class="p">,</span>
<span class="w"> </span><span class="s">"public class Quine"</span><span class="p">,</span>
<span class="w"> </span><span class="s">"{"</span><span class="p">,</span>
<span class="w"> </span><span class="s">" public static void main(String[] args)"</span><span class="p">,</span>
<span class="w"> </span><span class="s">" {"</span><span class="p">,</span>
<span class="w"> </span><span class="s">" char q = 34;"</span><span class="p">,</span>
<span class="w"> </span><span class="s">" String[] l = {"</span><span class="p">,</span>
<span class="w"> </span><span class="s">" };"</span><span class="p">,</span>
<span class="w"> </span><span class="s">" for(int i = 2; i &lt;= 9; i++)"</span><span class="p">,</span>
<span class="w"> </span><span class="s">" System.out.println(l[i]);"</span><span class="p">,</span>
<span class="w"> </span><span class="s">" for(int i = 0; i &lt; l.length; i++)"</span><span class="p">,</span>
<span class="w"> </span><span class="s">" System.out.println(l[0] + q + l[i] + q + ',');"</span><span class="p">,</span>
<span class="w"> </span><span class="s">" for(int i = 10; i &lt;= 18; i++)"</span><span class="p">,</span>
<span class="w"> </span><span class="s">" System.out.println(l[i]);"</span><span class="p">,</span>
<span class="w"> </span><span class="s">" }"</span><span class="p">,</span>
<span class="w"> </span><span class="s">"}"</span><span class="p">,</span>
<span class="w"> </span><span class="p">};</span>
<span class="w"> </span><span class="k">for</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">20</span><span class="p">;</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">&lt;=</span><span class="w"> </span><span class="mi">25</span><span class="p">;</span><span class="w"> </span><span class="n">i</span><span class="o">++</span><span class="p">)</span>
<span class="w"> </span><span class="n">cout</span><span class="w"> </span><span class="o">&lt;&lt;</span><span class="w"> </span><span class="n">l</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="w"> </span><span class="o">&lt;&lt;</span><span class="w"> </span><span class="n">endl</span><span class="p">;</span>
<span class="w"> </span><span class="k">for</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">0</span><span class="p">;</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">&lt;=</span><span class="w"> </span><span class="mi">34</span><span class="p">;</span><span class="w"> </span><span class="n">i</span><span class="o">++</span><span class="p">)</span>
<span class="w"> </span><span class="n">cout</span><span class="w"> </span><span class="o">&lt;&lt;</span><span class="w"> </span><span class="n">l</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="n">q</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="n">l</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="n">q</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="sc">','</span><span class="w"> </span><span class="o">&lt;&lt;</span><span class="w"> </span><span class="n">endl</span><span class="p">;</span>
<span class="w"> </span><span class="k">for</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">26</span><span class="p">;</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">&lt;=</span><span class="w"> </span><span class="mi">34</span><span class="p">;</span><span class="w"> </span><span class="n">i</span><span class="o">++</span><span class="p">)</span>
<span class="w"> </span><span class="n">cout</span><span class="w"> </span><span class="o">&lt;&lt;</span><span class="w"> </span><span class="n">l</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="w"> </span><span class="o">&lt;&lt;</span><span class="w"> </span><span class="n">endl</span><span class="p">;</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="mi">0</span><span class="p">;</span>
<span class="p">}</span>
</pre></div>
</div><div style="width: 49%; overflow: auto; float: left; padding-right: 1%;">
<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">Quine</span>
<span class="p">{</span>
<span class="w"> </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">main</span><span class="p">(</span><span class="n">String</span><span class="o">[]</span><span class="w"> </span><span class="n">args</span><span class="p">)</span>
<span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="kt">char</span><span class="w"> </span><span class="n">q</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">34</span><span class="p">;</span>
<span class="w"> </span><span class="n">String</span><span class="o">[]</span><span class="w"> </span><span class="n">l</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="s">" "</span><span class="p">,</span>
<span class="w"> </span><span class="s">"=============&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt; C++ Code &gt;&gt;&gt;&gt;&gt;&gt;&gt;&gt;============="</span><span class="p">,</span>
<span class="w"> </span><span class="s">"#include &lt;iostream&gt;"</span><span class="p">,</span>
<span class="w"> </span><span class="s">"#include &lt;string&gt;"</span><span class="p">,</span>
<span class="w"> </span><span class="s">"using namespace std;"</span><span class="p">,</span>
<span class="w"> </span><span class="s">""</span><span class="p">,</span>
<span class="w"> </span><span class="s">"int main(int argc, char* argv[])"</span><span class="p">,</span>
<span class="w"> </span><span class="s">"{"</span><span class="p">,</span>
<span class="w"> </span><span class="s">" char q = 34;"</span><span class="p">,</span>
<span class="w"> </span><span class="s">" string l[] = {"</span><span class="p">,</span>
<span class="w"> </span><span class="s">" };"</span><span class="p">,</span>
<span class="w"> </span><span class="s">" for(int i = 20; i &lt;= 25; i++)"</span><span class="p">,</span>
<span class="w"> </span><span class="s">" cout &lt;&lt; l[i] &lt;&lt; endl;"</span><span class="p">,</span>
<span class="w"> </span><span class="s">" for(int i = 0; i &lt;= 34; i++)"</span><span class="p">,</span>
<span class="w"> </span><span class="s">" cout &lt;&lt; l[0] + q + l[i] + q + ',' &lt;&lt; endl;"</span><span class="p">,</span>
<span class="w"> </span><span class="s">" for(int i = 26; i &lt;= 34; i++)"</span><span class="p">,</span>
<span class="w"> </span><span class="s">" cout &lt;&lt; l[i] &lt;&lt; endl;"</span><span class="p">,</span>
<span class="w"> </span><span class="s">" return 0;"</span><span class="p">,</span>
<span class="w"> </span><span class="s">"}"</span><span class="p">,</span>
<span class="w"> </span><span class="s">"=============&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt; Java Code &gt;&gt;&gt;&gt;&gt;&gt;&gt;&gt;============="</span><span class="p">,</span>
<span class="w"> </span><span class="s">"public class Quine"</span><span class="p">,</span>
<span class="w"> </span><span class="s">"{"</span><span class="p">,</span>
<span class="w"> </span><span class="s">" public static void main(String[] args)"</span><span class="p">,</span>
<span class="w"> </span><span class="s">" {"</span><span class="p">,</span>
<span class="w"> </span><span class="s">" char q = 34;"</span><span class="p">,</span>
<span class="w"> </span><span class="s">" String[] l = {"</span><span class="p">,</span>
<span class="w"> </span><span class="s">" };"</span><span class="p">,</span>
<span class="w"> </span><span class="s">" for(int i = 2; i &lt;= 9; i++)"</span><span class="p">,</span>
<span class="w"> </span><span class="s">" System.out.println(l[i]);"</span><span class="p">,</span>
<span class="w"> </span><span class="s">" for(int i = 0; i &lt; l.length; i++)"</span><span class="p">,</span>
<span class="w"> </span><span class="s">" System.out.println(l[0] + q + l[i] + q + ',');"</span><span class="p">,</span>
<span class="w"> </span><span class="s">" for(int i = 10; i &lt;= 18; i++)"</span><span class="p">,</span>
<span class="w"> </span><span class="s">" System.out.println(l[i]);"</span><span class="p">,</span>
<span class="w"> </span><span class="s">" }"</span><span class="p">,</span>
<span class="w"> </span><span class="s">"}"</span><span class="p">,</span>
<span class="w"> </span><span class="p">};</span>
<span class="w"> </span><span class="k">for</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">2</span><span class="p">;</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">&lt;=</span><span class="w"> </span><span class="mi">9</span><span class="p">;</span><span class="w"> </span><span class="n">i</span><span class="o">++</span><span class="p">)</span>
<span class="w"> </span><span class="n">System</span><span class="p">.</span><span class="na">out</span><span class="p">.</span><span class="na">println</span><span class="p">(</span><span class="n">l</span><span class="o">[</span><span class="n">i</span><span class="o">]</span><span class="p">);</span>
<span class="w"> </span><span class="k">for</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">0</span><span class="p">;</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">&lt;</span><span class="w"> </span><span class="n">l</span><span class="p">.</span><span class="na">length</span><span class="p">;</span><span class="w"> </span><span class="n">i</span><span class="o">++</span><span class="p">)</span>
<span class="w"> </span><span class="n">System</span><span class="p">.</span><span class="na">out</span><span class="p">.</span><span class="na">println</span><span class="p">(</span><span class="n">l</span><span class="o">[</span><span class="mi">0</span><span class="o">]</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="n">q</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="n">l</span><span class="o">[</span><span class="n">i</span><span class="o">]</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="n">q</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="sc">','</span><span class="p">);</span>
<span class="w"> </span><span class="k">for</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">10</span><span class="p">;</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">&lt;=</span><span class="w"> </span><span class="mi">18</span><span class="p">;</span><span class="w"> </span><span class="n">i</span><span class="o">++</span><span class="p">)</span>
<span class="w"> </span><span class="n">System</span><span class="p">.</span><span class="na">out</span><span class="p">.</span><span class="na">println</span><span class="p">(</span><span class="n">l</span><span class="o">[</span><span class="n">i</span><span class="o">]</span><span class="p">);</span>
<span class="w"> </span><span class="p">}</span>
<span class="p">}</span>
</pre></div></div>
<p>Such programs have been produced with various cycle lengths:
</p>
<ul><li><a href="Haskell_(programming_language)" class="mw-redirect" title="Haskell (programming language)">Haskell</a> → <a href="Python_(programming_language)" title="Python (programming language)">Python</a> → <a href="Ruby_(programming_language)" title="Ruby (programming language)">Ruby</a><sup id="cite_ref-8" class="reference"><a href="#cite_note-8"><span class="cite-bracket">[</span>7<span class="cite-bracket">]</span></a></sup></li>
<li><a href="Python_(programming_language)" title="Python (programming language)">Python</a> → <a href="Bash_(Unix_shell)" title="Bash (Unix shell)">Bash</a> → <a href="Perl" title="Perl">Perl</a><sup id="cite_ref-9" class="reference"><a href="#cite_note-9"><span class="cite-bracket">[</span>8<span class="cite-bracket">]</span></a></sup></li>
<li><a href="C_(programming_language)" title="C (programming language)">C</a> → <a href="Haskell_(programming_language)" class="mw-redirect" title="Haskell (programming language)">Haskell</a> → <a href="Python_(programming_language)" title="Python (programming language)">Python</a> → <a href="Perl" title="Perl">Perl</a><sup id="cite_ref-10" class="reference"><a href="#cite_note-10"><span class="cite-bracket">[</span>9<span class="cite-bracket">]</span></a></sup></li>
<li><a href="Haskell_(programming_language)" class="mw-redirect" title="Haskell (programming language)">Haskell</a> → <a href="Perl" title="Perl">Perl</a> → <a href="Python_(programming_language)" title="Python (programming language)">Python</a> → <a href="Ruby_(programming_language)" title="Ruby (programming language)">Ruby</a> → <a href="C_(programming_language)" title="C (programming language)">C</a> → <a href="Java_(programming_language)" title="Java (programming language)">Java</a><sup id="cite_ref-11" class="reference"><a href="#cite_note-11"><span class="cite-bracket">[</span>10<span class="cite-bracket">]</span></a></sup></li>
<li><a href="Ruby_(programming_language)" title="Ruby (programming language)">Ruby</a> → <a href="Java_(programming_language)" title="Java (programming language)">Java</a> → <a href="C_Sharp_(programming_language)" title="C Sharp (programming language)">C#</a> → <a href="Python_(programming_language)" title="Python (programming language)">Python</a><sup id="cite_ref-12" class="reference"><a href="#cite_note-12"><span class="cite-bracket">[</span>11<span class="cite-bracket">]</span></a></sup></li>
<li><a href="C_(programming_language)" title="C (programming language)">C</a> → <a href="C%2B%2B" title="C++">C++</a> → <a href="Ruby_(programming_language)" title="Ruby (programming language)">Ruby</a> → <a href="Python_(programming_language)" title="Python (programming language)">Python</a> → <a href="PHP" title="PHP">PHP</a> → <a href="Perl" title="Perl">Perl</a><sup id="cite_ref-13" class="reference"><a href="#cite_note-13"><span class="cite-bracket">[</span>12<span class="cite-bracket">]</span></a></sup></li>
<li><a href="Ruby_(programming_language)" title="Ruby (programming language)">Ruby</a> → <a href="Python_(programming_language)" title="Python (programming language)">Python</a> → <a href="Perl" title="Perl">Perl</a> → <a href="Lua_(programming_language)" class="mw-redirect" title="Lua (programming language)">Lua</a> → <a href="OCaml" title="OCaml">OCaml</a> → <a href="Haskell_(programming_language)" class="mw-redirect" title="Haskell (programming language)">Haskell</a> → <a href="C_(programming_language)" title="C (programming language)">C</a> → <a href="Java_(programming_language)" title="Java (programming language)">Java</a> → <a href="Brainfuck" title="Brainfuck">Brainfuck</a> → <a href="Whitespace_(programming_language)" title="Whitespace (programming language)">Whitespace</a> → <a href="Unlambda" title="Unlambda">Unlambda</a><sup id="cite_ref-14" class="reference"><a href="#cite_note-14"><span class="cite-bracket">[</span>13<span class="cite-bracket">]</span></a></sup></li>
<li><a href="Ruby_(programming_language)" title="Ruby (programming language)">Ruby</a> → <a href="Scala_(programming_language)" title="Scala (programming language)">Scala</a> → <a href="Scheme_(programming_language)" title="Scheme (programming language)">Scheme</a> → <a href="Scilab" title="Scilab">Scilab</a> → <a href="Bash_(Unix_shell)" title="Bash (Unix shell)">Shell (bash)</a> → <a href="S_(programming_language)" title="S (programming language)">S-Lang</a> → <a href="Smalltalk" title="Smalltalk">Smalltalk</a> → <a href="Squirrel_(programming_language)" title="Squirrel (programming language)">Squirrel3</a> → <a href="Standard_ML" title="Standard ML">Standard ML</a> → ... → <a href="Rexx" title="Rexx">Rexx</a> (128 (and formerly 50) programming languages)<sup id="cite_ref-15" class="reference"><a href="#cite_note-15"><span class="cite-bracket">[</span>14<span class="cite-bracket">]</span></a></sup></li>
<li>Web application → <a href="C_(programming_language)" title="C (programming language)">C</a> (web application source code consists of <a href="HTML" title="HTML">HTML</a>, <a href="JavaScript" title="JavaScript">JavaScript</a>, and <a href="CSS" title="CSS">CSS</a>)<sup id="cite_ref-16" class="reference"><a href="#cite_note-16"><span class="cite-bracket">[</span>15<span class="cite-bracket">]</span></a></sup></li></ul>
<div class="mw-heading mw-heading2"><h2 id="Multiquines">Multiquines</h2></div>
<p>David Madore, creator of <a href="Unlambda" title="Unlambda">Unlambda</a>, describes multiquines as follows:<sup id="cite_ref-17" class="reference"><a href="#cite_note-17"><span class="cite-bracket">[</span>16<span class="cite-bracket">]</span></a></sup>
</p>
<blockquote>
<p>"A multiquine is a set of r different programs (in r different languages – without this condition we could take them all equal to a single quine), each of which is able to print any of the r programs (including itself) according to the command line argument it is passed. (Cheating is not allowed: the command line arguments must not be too long – passing the full text of a program is considered cheating)."
</p>
</blockquote>
<p>A multiquine consisting of 2 languages (or biquine) would be a program which:
</p>
<ul><li>When run, is a quine in language X.</li>
<li>When supplied with a user-defined command line argument, would print a second program in language Y.</li>
<li>Given the second program in language Y, when run normally, would also be a quine in language Y.</li>
<li>Given the second program in language Y, and supplied with a user-defined command line argument, would produce the original program in language X.</li></ul>
<p>A biquine could then be seen as a set of two programs, both of which are able to print either of the two, depending on the command line argument supplied.
</p><p>Theoretically, there is no limit on the number of languages in a multiquine.
A 5-part multiquine (or pentaquine) has been produced with <a href="Python_(programming_language)" title="Python (programming language)">Python</a>, <a href="Perl" title="Perl">Perl</a>, <a href="C_(programming_language)" title="C (programming language)">C</a>, <a href="NewLISP" title="NewLISP">NewLISP</a>, and <a href="F_Sharp_(programming_language)" title="F Sharp (programming language)">F#</a><sup id="cite_ref-18" class="reference"><a href="#cite_note-18"><span class="cite-bracket">[</span>17<span class="cite-bracket">]</span></a></sup>
and there is also a 25-language multiquine.<sup id="cite_ref-19" class="reference"><a href="#cite_note-19"><span class="cite-bracket">[</span>18<span class="cite-bracket">]</span></a></sup>
</p>
<div class="mw-heading mw-heading2"><h2 id="Polyglot">Polyglot</h2></div>
<p>Similar to, but unlike a multiquine, a <a href="Polyglot_(computing)" title="Polyglot (computing)">polyglot</a> program is a computer program or script written in a valid form of multiple programming languages or file formats by combining their syntax. A polyglot program is not required to have a self-reproducing quality, although a polyglot program can also be a quine in one or more of its possible ways to execute.
</p><p>Unlike quines and multiquines, polyglot programs are not guaranteed to exist between arbitrary sets of languages as a result of Kleene's recursion theorem, because they rely on the interplay between the syntaxes, and not a provable property that one can always be embedded within another.
</p>
<div class="mw-heading mw-heading2"><h2 id="Radiation-hardened">Radiation-hardened</h2></div>
<p>A radiation-hardened quine is a quine that can have any single character removed and still produces the original program with no missing character. Of necessity, such quines are much more convoluted than ordinary quines, as is seen by the following example in <a href="Ruby_(programming_language)" title="Ruby (programming language)">Ruby</a>:<sup id="cite_ref-20" class="reference"><a href="#cite_note-20"><span class="cite-bracket">[</span>19<span class="cite-bracket">]</span></a></sup>
</p>
<div class="mw-highlight mw-highlight-lang-ruby mw-content-ltr" dir="ltr"><pre><span class="nb">eval</span><span class="o">=</span><span class="s1">'eval$q=%q(puts %q(10210/</span><span class="si">#{</span><span class="mi">1</span><span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="mi">1</span><span class="o">==</span><span class="mi">21</span><span class="si">}</span><span class="s1">}/.i rescue##/</span>

<span class="s1">1 1"[13,213].max_by{|s|s.size}#"##").gsub(/\d/){["=</span><span class="se">\47</span><span class="s1">eval$q=%q(</span><span class="si">#$q</span><span class="s1">)#</span><span class="se">\47</span><span class="s1">##</span><span class="se">\47</span>

<span class="s1">",:eval,:instance_,"||=9"][eval$&amp;]}</span>
<span class="s1">exit)#'</span><span class="c1">##'</span>

<span class="nb">instance_eval</span><span class="o">=</span><span class="s1">'eval$q=%q(puts %q(10210/</span><span class="si">#{</span><span class="mi">1</span><span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="mi">1</span><span class="o">==</span><span class="mi">21</span><span class="si">}</span><span class="s1">}/.i rescue##/</span>

<span class="s1">1 1"[13,213].max_by{|s|s.size}#"##").gsub(/\d/){["=</span><span class="se">\47</span><span class="s1">eval$q=%q(</span><span class="si">#$q</span><span class="s1">)#</span><span class="se">\47</span><span class="s1">##</span><span class="se">\47</span>

<span class="s1">",:eval,:instance_,"||=9"][eval$&amp;]}</span>
<span class="s1">exit)#'</span><span class="c1">##'</span>

<span class="sr">/</span><span class="si">#{</span><span class="nb">eval</span><span class="w"> </span><span class="nb">eval</span><span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="nb">eval</span><span class="o">==</span><span class="nb">instance_eval</span><span class="si">}</span><span class="sr">}/</span><span class="o">.</span><span class="n">i</span><span class="w"> </span><span class="k">rescue</span><span class="c1">##/</span>

<span class="nb">eval</span><span class="w"> </span><span class="nb">eval</span><span class="s2">"[eval||=9,instance_eval||=9].max_by{|s|s.size}#"</span><span class="c1">##"</span>
</pre></div>
<div class="mw-heading mw-heading2"><h2 id="Automatic_generation">Automatic generation</h2></div>
<p>Using <a href="Relational_programming" class="mw-redirect" title="Relational programming">relational programming</a> techniques, it is possible to generate quines automatically by transforming the interpreter (or equivalently, the compiler and runtime) of a language into a relational program, and then solving for a <a href="Fixed_point_(mathematics)" title="Fixed point (mathematics)">fixed point</a>.<sup id="cite_ref-21" class="reference"><a href="#cite_note-21"><span class="cite-bracket">[</span>20<span class="cite-bracket">]</span></a></sup>
</p>
<div class="mw-heading mw-heading2"><h2 id="See_also">See also</h2></div>
<style data-mw-deduplicate="TemplateStyles:r1266661725">
/* start https://en.wikipedia.org/ */


.mw-parser-output .portalbox{padding:0;margin:0.5em 0;display:table;box-sizing:border-box;max-width:175px;list-style:none}.mw-parser-output .portalborder{border:1px solid var(--border-color-base,#a2a9b1);padding:0.1em;background:var(--background-color-neutral-subtle,#f8f9fa)}.mw-parser-output .portalbox-entry{display:table-row;font-size:85%;line-height:110%;height:1.9em;font-style:italic;font-weight:bold}.mw-parser-output .portalbox-image{display:table-cell;padding:0.2em;vertical-align:middle;text-align:center}.mw-parser-output .portalbox-link{display:table-cell;padding:0.2em 0.2em 0.2em 0.3em;vertical-align:middle}@media(min-width:720px){.mw-parser-output .portalleft{margin:0.5em 1em 0.5em 0}.mw-parser-output .portalright{clear:right;float:right;margin:0.5em 0 0.5em 1em}}


/* end https://en.wikipedia.org/ */
</style>
<style data-mw-deduplicate="TemplateStyles:r1184024115">
/* start https://en.wikipedia.org/ */


.mw-parser-output .div-col{margin-top:0.3em;column-width:30em}.mw-parser-output .div-col-small{font-size:90%}.mw-parser-output .div-col-rules{column-rule:1px solid #aaa}.mw-parser-output .div-col dl,.mw-parser-output .div-col ol,.mw-parser-output .div-col ul{margin-top:0}.mw-parser-output .div-col li,.mw-parser-output .div-col dd{page-break-inside:avoid;break-inside:avoid-column}


/* end https://en.wikipedia.org/ */
</style><div class="div-col">
<ul><li><a href="Diagonal_lemma" title="Diagonal lemma">Diagonal lemma</a></li>
<li><a href="Droste_effect" title="Droste effect">Droste effect</a></li>
<li><a href="Fixed_point_combinator" class="mw-redirect" title="Fixed point combinator">Fixed point combinator</a></li>
<li><a href="Self-modifying_code" title="Self-modifying code">Self-modifying code</a></li>
<li><a href="Self-interpreter" class="mw-redirect" title="Self-interpreter">Self-interpreter</a></li>
<li><a href="Self-replicating_machine" title="Self-replicating machine">Self-replicating machine</a></li>
<li><a href="Self-replication" title="Self-replication">Self-replication</a></li>
<li><a href="Self-relocation" title="Self-relocation">Self-relocation</a></li>
<li><a href="TiddlyWiki" title="TiddlyWiki">TiddlyWiki</a></li>
<li><a href="Tupper's_self-referential_formula" title="Tupper's self-referential formula">Tupper's self-referential formula</a></li>
<li><a href="Programming_languages" class="mw-redirect" title="Programming languages">Programming languages</a></li>
<li><a href="Quine's_paradox" title="Quine's paradox">Quine's paradox</a></li>
<li><a href="Polyglot_(computing)" title="Polyglot (computing)">Polyglot (computing)</a></li></ul>
</div>
<div class="mw-heading mw-heading2"><h2 id="Notes">Notes</h2></div>
<style data-mw-deduplicate="TemplateStyles:r1239543626">
/* start https://en.wikipedia.org/ */


.mw-parser-output .reflist{margin-bottom:0.5em;list-style-type:decimal}@media screen{.mw-parser-output .reflist{font-size:90%}}.mw-parser-output .reflist .references{font-size:100%;margin-bottom:0;list-style-type:inherit}.mw-parser-output .reflist-columns-2{column-width:30em}.mw-parser-output .reflist-columns-3{column-width:25em}.mw-parser-output .reflist-columns{margin-top:0.3em}.mw-parser-output .reflist-columns ol{margin-top:0}.mw-parser-output .reflist-columns li{page-break-inside:avoid;break-inside:avoid-column}.mw-parser-output .reflist-upper-alpha{list-style-type:upper-alpha}.mw-parser-output .reflist-upper-roman{list-style-type:upper-roman}.mw-parser-output .reflist-lower-alpha{list-style-type:lower-alpha}.mw-parser-output .reflist-lower-greek{list-style-type:lower-greek}.mw-parser-output .reflist-lower-roman{list-style-type:lower-roman}


/* end https://en.wikipedia.org/ */
</style><div class="reflist reflist-columns references-column-width reflist-lower-alpha" style="column-width: 30em;">
<ol class="references">
<li id="cite_note-5"><span class="mw-cite-backlink"><b><a href="#cite_ref-5">^</a></b></span> <span class="reference-text">Examples include <a href="Bash_(Unix_shell)" title="Bash (Unix shell)">Bash</a>, <a href="Perl" title="Perl">Perl</a>, and <a href="Python_(programming_language)" title="Python (programming language)">Python</a></span>
</li>
</ol></div>
<div class="mw-heading mw-heading2"><h2 id="References">References</h2></div>
<div class="reflist reflist-columns references-column-width" style="column-width: 30em;">
<ol class="references">
<li id="cite_note-Bratley_Millo-1"><span class="mw-cite-backlink"><b><a href="#cite_ref-Bratley_Millo_1-0">^</a></b></span> <span class="reference-text"><style data-mw-deduplicate="TemplateStyles:r1238218222">
/* start https://en.wikipedia.org/ */


.mw-parser-output cite.citation{font-style:inherit;word-wrap:break-word}.mw-parser-output .citation q{quotes:"\"""\"""'""'"}.mw-parser-output .citation:target{background-color:rgba(0,127,255,0.133)}.mw-parser-output .id-lock-free.id-lock-free a{background:url("./mw/Lock-green.svg")right 0.1em center/9px no-repeat}.mw-parser-output .id-lock-limited.id-lock-limited a,.mw-parser-output .id-lock-registration.id-lock-registration a{background:url("./mw/Lock-gray-alt-2.svg")right 0.1em center/9px no-repeat}.mw-parser-output .id-lock-subscription.id-lock-subscription a{background:url("./mw/Lock-red-alt-2.svg")right 0.1em center/9px no-repeat}.mw-parser-output .cs1-ws-icon a{background:url("./mw/Wikisource-logo.svg")right 0.1em center/12px no-repeat}body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-free a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-limited a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-registration a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-subscription a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .cs1-ws-icon a{background-size:contain;padding:0 1em 0 0}.mw-parser-output .cs1-code{color:inherit;background:inherit;border:none;padding:inherit}.mw-parser-output .cs1-hidden-error{display:none;color:var(--color-error,#d33)}.mw-parser-output .cs1-visible-error{color:var(--color-error,#d33)}.mw-parser-output .cs1-maint{display:none;color:#085;margin-left:0.3em}.mw-parser-output .cs1-kern-left{padding-left:0.2em}.mw-parser-output .cs1-kern-right{padding-right:0.2em}.mw-parser-output .citation .mw-selflink{font-weight:inherit}@media screen{.mw-parser-output .cs1-format{font-size:95%}html.skin-theme-clientpref-night .mw-parser-output .cs1-maint{color:#18911f}}@media screen and (prefers-color-scheme:dark){html.skin-theme-clientpref-os .mw-parser-output .cs1-maint{color:#18911f}}


/* end https://en.wikipedia.org/ */
</style><cite id="CITEREFBratleyMillo1972" class="citation journal cs1">Bratley, Paul; Millo, Jean (1972). "Computer Recreations: Self-Reproducing Automata". <i>Software: Practice and Experience</i>. <b>2</b> (4): <span class="nowrap">397–</span>400. <a href="Doi_(identifier)" class="mw-redirect" title="Doi (identifier)">doi</a>:<a rel="nofollow" class="external text" href="https://doi.org/10.1002%2Fspe.4380020411">10.1002/spe.4380020411</a>. <a href="S2CID_(identifier)" class="mw-redirect" title="S2CID (identifier)">S2CID</a>&nbsp;<a rel="nofollow" class="external text" href="https://api.semanticscholar.org/CorpusID:222194376">222194376</a>.</cite></span>
</li>
<li id="cite_note-Stet_and_AGPLV3-2"><span class="mw-cite-backlink"><b><a href="#cite_ref-Stet_and_AGPLV3_2-0">^</a></b></span> <span class="reference-text"><cite id="CITEREFKuhn2007" class="citation web cs1"><a href="Bradley_M._Kuhn" title="Bradley M. Kuhn">Kuhn, Bradley M.</a> (November 21, 2007). <a rel="nofollow" class="external text" href="https://web.archive.org/web/20080315231323/http://www.softwarefreedom.org/technology/blog/2007/nov/21/stet-and-agplv3/">"stet and AGPLv3"</a>. Software Freedom Law Center. Archived from <a rel="nofollow" class="external text" href="http://www.softwarefreedom.org/technology/blog/2007/nov/21/stet-and-agplv3/">the original</a> on March 15, 2008<span class="reference-accessdate">. Retrieved <span class="nowrap">June 14,</span> 2008</span>.</cite></span>
</li>
<li id="cite_note-3"><span class="mw-cite-backlink"><b><a href="#cite_ref-3">^</a></b></span> <span class="reference-text"><cite class="citation web cs1"><a rel="nofollow" class="external text" href="http://wiki.c2.com/?QuineProgram">"Quine Program"</a>. <i>wiki.c2.com</i>.</cite></span>
</li>
<li id="cite_note-4"><span class="mw-cite-backlink"><b><a href="#cite_ref-4">^</a></b></span> <span class="reference-text"><cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://gist.github.com/destan/c0db5a237e9875a56141403aaa6cb9c7">"Simple Java quine, self replicating (Self copying) Java code, with text blocks. This code can be run with Java 15+ or Java 13+ with special flags. License is public domain, no rights reserved"</a>.</cite></span>
</li>
<li id="cite_note-6"><span class="mw-cite-backlink"><b><a href="#cite_ref-6">^</a></b></span> <span class="reference-text"><cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://web.archive.org/web/20201112015540/http://www0.us.ioccc.org/1994/smr.hint">"IOCCC 1994 Worst Abuse of the Rules"</a>. Archived from <a rel="nofollow" class="external text" href="http://www0.us.ioccc.org/1994/smr.hint">the original</a> on 12 November 2020.</cite></span>
</li>
<li id="cite_note-7"><span class="mw-cite-backlink"><b><a href="#cite_ref-7">^</a></b></span> <span class="reference-text"><cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://web.archive.org/web/20190423002150/http://www0.us.ioccc.org/1994/Makefile">"Makefile"</a>. <i>IOCCC.org</i>. Archived from <a rel="nofollow" class="external text" href="http://www0.us.ioccc.org/1994/Makefile">the original</a> on 23 April 2019<span class="reference-accessdate">. Retrieved <span class="nowrap">4 April</span> 2019</span>.</cite></span>
</li>
<li id="cite_note-8"><span class="mw-cite-backlink"><b><a href="#cite_ref-8">^</a></b></span> <span class="reference-text"><cite id="CITEREFDan_Piponi2008" class="citation web cs1">Dan Piponi (5 February 2008). <a rel="nofollow" class="external text" href="http://blog.sigfpe.com/2008/02/third-order-quine-in-three-languages.html">"A Third Order Quine in Three Languages"</a>.</cite></span>
</li>
<li id="cite_note-9"><span class="mw-cite-backlink"><b><a href="#cite_ref-9">^</a></b></span> <span class="reference-text"><cite id="CITEREFBruce_Ediger" class="citation web cs1">Bruce Ediger. <a rel="nofollow" class="external text" href="https://web.archive.org/web/20110223164033/http://www.stratigery.com/source.html#Ouroboros">"Ask and ye shall receive: Self-replicating program that goes through three generations, Python, Bash, Perl"</a>. Archived from <a rel="nofollow" class="external text" href="http://www.stratigery.com/source.html#Ouroboros">the original</a> on 2011-02-23<span class="reference-accessdate">. Retrieved <span class="nowrap">2011-03-17</span></span>.</cite></span>
</li>
<li id="cite_note-10"><span class="mw-cite-backlink"><b><a href="#cite_ref-10">^</a></b></span> <span class="reference-text"><cite id="CITEREFb.m.2011" class="citation web cs1">b.m. (1 February 2011). <a rel="nofollow" class="external text" href="https://archive.today/20130415050710/http://hpaste.org/43501/multiquine">"multiquine"</a>. Archived from <a rel="nofollow" class="external text" href="http://hpaste.org/43501/multiquine">the original</a> on 2013-04-15.</cite></span>
</li>
<li id="cite_note-11"><span class="mw-cite-backlink"><b><a href="#cite_ref-11">^</a></b></span> <span class="reference-text"><cite id="CITEREFDan_Piponi2011" class="citation web cs1">Dan Piponi (30 January 2011). <a rel="nofollow" class="external text" href="http://blog.sigfpe.com/2011/01/quine-central.html">"Quine Central"</a>.</cite></span>
</li>
<li id="cite_note-12"><span class="mw-cite-backlink"><b><a href="#cite_ref-12">^</a></b></span> <span class="reference-text"><cite id="CITEREFRuslan_Ibragimov2013" class="citation web cs1 cs1-prop-foreign-lang-source">Ruslan Ibragimov (20 April 2013). <a rel="nofollow" class="external text" href="https://web.archive.org/web/20160304040341/http://ruslan.ibragimov.by/20-04-2013.quine-ruby-java-c-python">"Quine Ruby -&gt; Java -&gt; C# -&gt; Python"</a> (in Russian). Archived from <a rel="nofollow" class="external text" href="http://ruslan.ibragimov.by/20-04-2013.quine-ruby-java-c-python">the original</a> on 4 March 2016<span class="reference-accessdate">. Retrieved <span class="nowrap">20 April</span> 2013</span>.</cite></span>
</li>
<li id="cite_note-13"><span class="mw-cite-backlink"><b><a href="#cite_ref-13">^</a></b></span> <span class="reference-text"><cite id="CITEREFShinichiro_Hamaji2007" class="citation web cs1">Shinichiro Hamaji (10 November 2007). <a rel="nofollow" class="external text" href="http://golf.shinh.org/reveal.rb?Quine/shinh+%28C+C%2B%2B+Ruby+Python+PHP+Perl%29_1194650418&amp;rb">"Quine by shinh (C C++ Ruby Python PHP Perl)"</a>.</cite> (this one is also a <a href="Polyglot_(computing)" title="Polyglot (computing)">polyglot</a>)</span>
</li>
<li id="cite_note-14"><span class="mw-cite-backlink"><b><a href="#cite_ref-14">^</a></b></span> <span class="reference-text"><cite id="CITEREFKu-ma-me2009" class="citation web cs1">Ku-ma-me (22 September 2009). <a rel="nofollow" class="external text" href="https://web.archive.org/web/20110829204605/http://asiajin.com/blog/2009/09/22/uroboros-programming-with-11-programming-languages/">"Uroboros Programming With 11 Programming Languages"</a>. Archived from <a rel="nofollow" class="external text" href="http://asiajin.com/blog/2009/09/22/uroboros-programming-with-11-programming-languages/">the original</a> on 29 August 2011<span class="reference-accessdate">. Retrieved <span class="nowrap">17 March</span> 2011</span>.</cite></span>
</li>
<li id="cite_note-15"><span class="mw-cite-backlink"><b><a href="#cite_ref-15">^</a></b></span> <span class="reference-text"><cite id="CITEREFYusuke_Endoh2021" class="citation web cs1">Yusuke Endoh (2 November 2021). <a rel="nofollow" class="external text" href="https://github.com/mame/quine-relay">"Quine Relay - An uroboros program with 100+ programming languages"</a>. <i><a href="GitHub" title="GitHub">GitHub</a></i>.</cite></span>
</li>
<li id="cite_note-16"><span class="mw-cite-backlink"><b><a href="#cite_ref-16">^</a></b></span> <span class="reference-text"><cite id="CITEREFMichael_Wehar2019" class="citation web cs1">Michael Wehar (10 November 2019). <a rel="nofollow" class="external text" href="http://michaelwehar.com/quines/c_prints_javascript.html">"C Prints JavaScript"</a>.</cite></span>
</li>
<li id="cite_note-17"><span class="mw-cite-backlink"><b><a href="#cite_ref-17">^</a></b></span> <span class="reference-text"><cite id="CITEREFDavid_Madore" class="citation web cs1">David Madore. <a rel="nofollow" class="external text" href="http://www.madore.org/~david/computers/quine.html">"Quines (self-replicating programs)"</a>.</cite></span>
</li>
<li id="cite_note-18"><span class="mw-cite-backlink"><b><a href="#cite_ref-18">^</a></b></span> <span class="reference-text"><cite id="CITEREFRijnard_van_Tonder2020" class="citation web cs1">Rijnard van Tonder (14 January 2020). <a rel="nofollow" class="external text" href="https://github.com/rvantonder/pentaquine">"Pentaquine - 5 part multiquine"</a>. <i><a href="GitHub" title="GitHub">GitHub</a></i>.</cite></span>
</li>
<li id="cite_note-19"><span class="mw-cite-backlink"><b><a href="#cite_ref-19">^</a></b></span> <span class="reference-text"><cite id="CITEREFLu_Wang2021" class="citation web cs1">Lu Wang (21 May 2021). <a rel="nofollow" class="external text" href="https://github.com/coolwanglu/quine-chameleon#variants">"Quine Chameleon#Variants"</a>. <i><a href="GitHub" title="GitHub">GitHub</a></i>.</cite></span>
</li>
<li id="cite_note-20"><span class="mw-cite-backlink"><b><a href="#cite_ref-20">^</a></b></span> <span class="reference-text"><cite id="CITEREFYusuke_Endoh" class="citation web cs1">Yusuke Endoh. <a rel="nofollow" class="external text" href="https://github.com/mame/radiation-hardened-quine">"Radiation-hardened Quine"</a>. <i><a href="GitHub" title="GitHub">GitHub</a></i><span class="reference-accessdate">. Retrieved <span class="nowrap">2014-02-24</span></span>.</cite></span>
</li>
<li id="cite_note-21"><span class="mw-cite-backlink"><b><a href="#cite_ref-21">^</a></b></span> <span class="reference-text"><cite id="CITEREFByrdHolkFriedman2012" class="citation book cs1">Byrd, William E.; Holk, Eric; Friedman, Daniel P. (2012-09-09). <a rel="nofollow" class="external text" href="http://webyrd.net/quines/quines.pdf">"MiniKanren, live and untagged: Quine generation via relational interpreters (Programming pearl)"</a> <span class="cs1-format">(PDF)</span>. <i>Proceedings of the 2012 Annual Workshop on Scheme and Functional Programming</i>. Scheme '12. New York, NY, USA: Association for Computing Machinery. pp.&nbsp;<span class="nowrap">8–</span>29. <a href="Doi_(identifier)" class="mw-redirect" title="Doi (identifier)">doi</a>:<a rel="nofollow" class="external text" href="https://doi.org/10.1145%2F2661103.2661105">10.1145/2661103.2661105</a>. <a href="ISBN_(identifier)" class="mw-redirect" title="ISBN (identifier)">ISBN</a>&nbsp;<bdi>978-1-4503-1895-2</bdi>.</cite></span>
</li>
</ol></div>
<div class="mw-heading mw-heading2"><h2 id="Further_reading">Further reading</h2></div>
<ul><li><a href="Douglas_Hofstadter" title="Douglas Hofstadter">Douglas Hofstadter</a>: <i><a href="G%C3%B6del%2C_Escher%2C_Bach%3A_An_Eternal_Golden_Braid" class="mw-redirect" title="Gödel, Escher, Bach: An Eternal Golden Braid">Gödel, Escher, Bach: An Eternal Golden Braid</a></i></li>
<li><a href="Ken_Thompson" title="Ken Thompson">Ken Thompson</a>: "<a rel="nofollow" class="external text" href="https://www.ece.cmu.edu/~ganger/712.fall02/papers/p761-thompson.pdf">Reflections on Trusting Trust</a>" (<i><a href="Communications_of_the_ACM" title="Communications of the ACM">Communications of the ACM</a></i>, <b>27</b>(8):761-3)</li></ul>
<div class="mw-heading mw-heading2"><h2 id="External_links">External links</h2></div>
<div class="div-col" style="column-width: 30em;">
<ul><li><a rel="nofollow" class="external text" href="http://tiddlywiki.com/#Quine:Quine%20HelloThere%20GettingStarted%20Community">TiddlyWiki, a quine manifested as a wiki</a></li>
<li><a rel="nofollow" class="external text" href="http://www.nyx.net/~gthompso/quine.htm">The Quine Page (by Gary P. Thompson)</a></li>
<li><a rel="nofollow" class="external text" href="http://michaelwehar.com/quines/">A Brief Guide to Self-Referential Programs</a></li>
<li><a rel="nofollow" class="external text" href="http://c2.com/cgi/wiki?QuineProgram">QuineProgram at the Portland Pattern Repository Wiki</a></li>
<li><a rel="nofollow" class="external text" href="http://www.madore.org/~david/computers/quine.html">David Madore's Discussion of Quines</a></li>
<li><a rel="nofollow" class="external text" href="http://www.steike.com/code/useless/zip-file-quine/">Zip File Quine</a></li>
<li><a rel="nofollow" class="external text" href="http://research.swtch.com/2010/03/zip-files-all-way-down.html">Zip Files All The Way Down</a></li>
<li><a rel="nofollow" class="external text" href="http://johannesloetzsch.de/software/quines/">An Introduction to Quines — in particular, quines using more than one language</a></li>
<li><a rel="nofollow" class="external text" href="http://www.win.tue.nl/~wstomv/edu/javascript/quine.html">Quine Web Page: A standards-conforming HTML+JavaScript web page that shows its own source code</a></li>
<li><a rel="nofollow" class="external text" href="https://no-gravity.github.io/html-quine/">HTML Quine: An HTML page that only uses HTML and CSS to show its own source code</a></li>
<li><a rel="nofollow" class="external text" href="http://www.win.tue.nl/~wstomv/edu/javascript/challenge.html">Quine Challenge for Tom's JavaScript Machine</a>, with a series of interactive hints</li>
<li><a rel="nofollow" class="external text" href="http://www-verimag.imag.fr/~monniaux/download/JavaQuine.zip">A Java Quine built straight from Kleene's fixed point theorem, composition and s-n-m</a></li>
<li><a rel="nofollow" class="external text" href="https://quaxio.com/qrquine/">A QR code quine</a></li></ul>
</div>
<div class="navbox-styles"><style data-mw-deduplicate="TemplateStyles:r1129693374">
/* start https://en.wikipedia.org/ */


.mw-parser-output .hlist dl,.mw-parser-output .hlist ol,.mw-parser-output .hlist ul{margin:0;padding:0}.mw-parser-output .hlist dd,.mw-parser-output .hlist dt,.mw-parser-output .hlist li{margin:0;display:inline}.mw-parser-output .hlist.inline,.mw-parser-output .hlist.inline dl,.mw-parser-output .hlist.inline ol,.mw-parser-output .hlist.inline ul,.mw-parser-output .hlist dl dl,.mw-parser-output .hlist dl ol,.mw-parser-output .hlist dl ul,.mw-parser-output .hlist ol dl,.mw-parser-output .hlist ol ol,.mw-parser-output .hlist ol ul,.mw-parser-output .hlist ul dl,.mw-parser-output .hlist ul ol,.mw-parser-output .hlist ul ul{display:inline}.mw-parser-output .hlist .mw-empty-li{display:none}.mw-parser-output .hlist dt::after{content:": "}.mw-parser-output .hlist dd::after,.mw-parser-output .hlist li::after{content:" · ";font-weight:bold}.mw-parser-output .hlist dd:last-child::after,.mw-parser-output .hlist dt:last-child::after,.mw-parser-output .hlist li:last-child::after{content:none}.mw-parser-output .hlist dd dd:first-child::before,.mw-parser-output .hlist dd dt:first-child::before,.mw-parser-output .hlist dd li:first-child::before,.mw-parser-output .hlist dt dd:first-child::before,.mw-parser-output .hlist dt dt:first-child::before,.mw-parser-output .hlist dt li:first-child::before,.mw-parser-output .hlist li dd:first-child::before,.mw-parser-output .hlist li dt:first-child::before,.mw-parser-output .hlist li li:first-child::before{content:" (";font-weight:normal}.mw-parser-output .hlist dd dd:last-child::after,.mw-parser-output .hlist dd dt:last-child::after,.mw-parser-output .hlist dd li:last-child::after,.mw-parser-output .hlist dt dd:last-child::after,.mw-parser-output .hlist dt dt:last-child::after,.mw-parser-output .hlist dt li:last-child::after,.mw-parser-output .hlist li dd:last-child::after,.mw-parser-output .hlist li dt:last-child::after,.mw-parser-output .hlist li li:last-child::after{content:")";font-weight:normal}.mw-parser-output .hlist ol{counter-reset:listitem}.mw-parser-output .hlist ol>li{counter-increment:listitem}.mw-parser-output .hlist ol>li::before{content:" "counter(listitem)"\a0 "}.mw-parser-output .hlist dd ol>li:first-child::before,.mw-parser-output .hlist dt ol>li:first-child::before,.mw-parser-output .hlist li ol>li:first-child::before{content:" ("counter(listitem)"\a0 "}


/* end https://en.wikipedia.org/ */
</style><style data-mw-deduplicate="TemplateStyles:r1236075235">
/* start https://en.wikipedia.org/ */


.mw-parser-output .navbox{box-sizing:border-box;border:1px solid #a2a9b1;width:100%;clear:both;font-size:88%;text-align:center;padding:1px;margin:1em auto 0}.mw-parser-output .navbox .navbox{margin-top:0}.mw-parser-output .navbox+.navbox,.mw-parser-output .navbox+.navbox-styles+.navbox{margin-top:-1px}.mw-parser-output .navbox-inner,.mw-parser-output .navbox-subgroup{width:100%}.mw-parser-output .navbox-group,.mw-parser-output .navbox-title,.mw-parser-output .navbox-abovebelow{padding:0.25em 1em;line-height:1.5em;text-align:center}.mw-parser-output .navbox-group{white-space:nowrap;text-align:right}.mw-parser-output .navbox,.mw-parser-output .navbox-subgroup{background-color:#fdfdfd}.mw-parser-output .navbox-list{line-height:1.5em;border-color:#fdfdfd}.mw-parser-output .navbox-list-with-group{text-align:left;border-left-width:2px;border-left-style:solid}.mw-parser-output tr+tr>.navbox-abovebelow,.mw-parser-output tr+tr>.navbox-group,.mw-parser-output tr+tr>.navbox-image,.mw-parser-output tr+tr>.navbox-list{border-top:2px solid #fdfdfd}.mw-parser-output .navbox-title{background-color:#ccf}.mw-parser-output .navbox-abovebelow,.mw-parser-output .navbox-group,.mw-parser-output .navbox-subgroup .navbox-title{background-color:#ddf}.mw-parser-output .navbox-subgroup .navbox-group,.mw-parser-output .navbox-subgroup .navbox-abovebelow{background-color:#e6e6ff}.mw-parser-output .navbox-even{background-color:#f7f7f7}.mw-parser-output .navbox-odd{background-color:transparent}.mw-parser-output .navbox .hlist td dl,.mw-parser-output .navbox .hlist td ol,.mw-parser-output .navbox .hlist td ul,.mw-parser-output .navbox td.hlist dl,.mw-parser-output .navbox td.hlist ol,.mw-parser-output .navbox td.hlist ul{padding:0.125em 0}.mw-parser-output .navbox .navbar{display:block;font-size:100%}.mw-parser-output .navbox-title .navbar{float:left;text-align:left;margin-right:0.5em}body.skin--responsive .mw-parser-output .navbox-image img{max-width:none!important}@media print{body.ns-0 .mw-parser-output .navbox{display:none!important}}


/* end https://en.wikipedia.org/ */
</style></div><div role="navigation" class="navbox" aria-labelledby="Standard_test_items314" style="padding:3px"><table class="nowraplinks mw-collapsible autocollapse navbox-inner" style="border-spacing:0;background:transparent;color:inherit"><tbody><tr><th scope="col" class="navbox-title" colspan="2"><style data-mw-deduplicate="TemplateStyles:r1239400231">
/* start https://en.wikipedia.org/ */


.mw-parser-output .navbar{display:inline;font-size:88%;font-weight:normal}.mw-parser-output .navbar-collapse{float:left;text-align:left}.mw-parser-output .navbar-boxtext{word-spacing:0}.mw-parser-output .navbar ul{display:inline-block;white-space:nowrap;line-height:inherit}.mw-parser-output .navbar-brackets::before{margin-right:-0.125em;content:"[ "}.mw-parser-output .navbar-brackets::after{margin-left:-0.125em;content:" ]"}.mw-parser-output .navbar li{word-spacing:-0.125em}.mw-parser-output .navbar a>span,.mw-parser-output .navbar a>abbr{text-decoration:inherit}.mw-parser-output .navbar-mini abbr{font-variant:small-caps;border-bottom:none;text-decoration:none;cursor:inherit}.mw-parser-output .navbar-ct-full{font-size:114%;margin:0 7em}.mw-parser-output .navbar-ct-mini{font-size:114%;margin:0 4em}html.skin-theme-clientpref-night .mw-parser-output .navbar li a abbr{color:var(--color-base)!important}@media(prefers-color-scheme:dark){html.skin-theme-clientpref-os .mw-parser-output .navbar li a abbr{color:var(--color-base)!important}}@media print{.mw-parser-output .navbar{display:none!important}}


/* end https://en.wikipedia.org/ */
</style><div id="Standard_test_items314" style="font-size:114%;margin:0 4em">Standard test items</div></th></tr><tr><td class="navbox-abovebelow hlist" colspan="2"><div>
<ul><li><a href="Pangram" title="Pangram">Pangram</a></li>
<li><a href="Reference_implementation" title="Reference implementation">Reference implementation</a></li>
<li><a href="Sanity_check" title="Sanity check">Sanity check</a></li>
<li><a href="Standard_test_image" title="Standard test image">Standard test image</a></li></ul>
</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Artificial_intelligence" title="Artificial intelligence">Artificial intelligence</a><br>(<a href="Machine_learning" title="Machine learning">Machine learning</a>)</th><td class="navbox-list-with-group navbox-list navbox-odd hlist" style="width:100%;padding:0"><div style="padding:0 0.25em">
<ul><li><a href="Chinese_room" title="Chinese room">Chinese room</a></li>
<li><a href="ImageNet" title="ImageNet">ImageNet</a></li>
<li><a href="MNIST_database" title="MNIST database">MNIST database</a></li>
<li><a href="Turing_test" title="Turing test">Turing test</a></li>
<li><a href="List_of_datasets_for_machine-learning_research" title="List of datasets for machine-learning research">List</a></li></ul>
</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%">Television (<a href="Test_card" title="Test card">test card</a>)</th><td class="navbox-list-with-group navbox-list navbox-even hlist" style="width:100%;padding:0"><div style="padding:0 0.25em">
<ul><li><a href="SMPTE_color_bars" title="SMPTE color bars">SMPTE color bars</a></li>
<li><a href="EBU_colour_bars" title="EBU colour bars">EBU colour bars</a></li>
<li><a href="Indian-head_test_pattern" title="Indian-head test pattern">Indian-head test pattern</a></li>
<li><a href="EIA_1956_resolution_chart" title="EIA 1956 resolution chart">EIA 1956 resolution chart</a></li>
<li><a href="List_of_BBC_test_cards" title="List of BBC test cards">BBC Test Card</a> <a href="List_of_BBC_test_cards#Test_Card_A" title="List of BBC test cards">A</a>, <a href="List_of_BBC_test_cards#Test_Card_B" title="List of BBC test cards">B</a>, <a href="List_of_BBC_test_cards#Test_Card_C" title="List of BBC test cards">C</a>, <a href="List_of_BBC_test_cards#Test_Card_D" title="List of BBC test cards">D</a>, <a href="List_of_BBC_test_cards#Test_Card_E_(later_Test_Card_C)" title="List of BBC test cards">E</a>, <a href="Test_Card_F" title="Test Card F">F</a>, <a href="List_of_BBC_test_cards#Test_Card_G" title="List of BBC test cards">G</a>, <a href="List_of_BBC_test_cards#Test_Card_H" title="List of BBC test cards">H</a>, <a href="Test_Card_F#testcardj" title="Test Card F">J</a>, <a href="Test_Card_F#testcardw" title="Test Card F">W</a>, <a href="Test_Card_F#testcardx" title="Test Card F">X</a></li>
<li><a href="ETP-1" title="ETP-1">ETP-1</a></li>
<li><a href="Philips_circle_pattern" title="Philips circle pattern">Philips circle pattern</a> (<a href="Philips_circle_pattern#PM5534" title="Philips circle pattern">PM 5538</a>, <a href="Philips_PM5540" title="Philips PM5540">PM 5540</a>, <a href="Philips_circle_pattern#PM5544" title="Philips circle pattern">PM 5544</a>, <a href="Philips_circle_pattern#PM5644" title="Philips circle pattern">PM 5644</a>)</li>
<li><a href="Snell_%26_Wilcox_Zone_Plate" title="Snell &amp; Wilcox Zone Plate">Snell &amp; Wilcox SW2/SW4</a></li>
<li><a href="Telefunken_FuBK" title="Telefunken FuBK">Telefunken FuBK</a></li>
<li><a href="TVE_test_card" title="TVE test card">TVE test card</a></li>
<li><a href="Universal_Electronic_Test_Chart" title="Universal Electronic Test Chart">UEIT</a></li></ul>
</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Computer_language" title="Computer language">Computer languages</a></th><td class="navbox-list-with-group navbox-list navbox-odd hlist" style="width:100%;padding:0"><div style="padding:0 0.25em">
<ul><li><a href="%22Hello%2C_World!%22_program" title="&quot;Hello, World!&quot; program">"Hello, World!" program</a></li>

<li><a href="TPK_algorithm" title="TPK algorithm">Trabb Pardo–Knuth algorithm</a></li>
<li><a href="Man_or_boy_test" title="Man or boy test">Man or boy test</a></li>
<li><a href="Perl#Community" title="Perl">Just another Perl hacker</a></li></ul>
</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Data_compression" title="Data compression">Data compression</a></th><td class="navbox-list-with-group navbox-list navbox-even hlist" style="width:100%;padding:0"><div style="padding:0 0.25em">
<ul><li><a href="Calgary_corpus" title="Calgary corpus">Calgary corpus</a></li>
<li><a href="Canterbury_corpus" title="Canterbury corpus">Canterbury corpus</a></li>
<li><a href="Silesia_corpus" title="Silesia corpus">Silesia corpus</a></li>
<li><a href="Hutter_Prize" title="Hutter Prize">enwik8, enwik9</a></li></ul>
</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="3D_computer_graphics" title="3D computer graphics">3D computer graphics</a></th><td class="navbox-list-with-group navbox-list navbox-odd hlist" style="width:100%;padding:0"><div style="padding:0 0.25em">
<ul><li><a href="3DBenchy" title="3DBenchy">3DBenchy</a></li>
<li><a href="Cornell_box" title="Cornell box">Cornell box</a></li>
<li><a href="Stanford_bunny" title="Stanford bunny">Stanford bunny</a></li>
<li><a href="Stanford_dragon" title="Stanford dragon">Stanford dragon</a></li>
<li><a href="Utah_teapot" title="Utah teapot">Utah teapot</a></li>
<li><a href="List_of_common_3D_test_models" title="List of common 3D test models">List</a></li></ul>
</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="2D_computer_graphics" title="2D computer graphics">2D computer graphics</a></th><td class="navbox-list-with-group navbox-list navbox-even hlist" style="width:100%;padding:0"><div style="padding:0 0.25em">
<ul><li>Ghostscript tiger</li>
<li><a href="Lenna" title="Lenna">Lena</a></li></ul>
</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Typography" title="Typography">Typography</a> (<a href="Filler_text" title="Filler text">filler text</a>)</th><td class="navbox-list-with-group navbox-list navbox-odd hlist" style="width:100%;padding:0"><div style="padding:0 0.25em">
<ul><li><a href="Etaoin_shrdlu" title="Etaoin shrdlu">Etaoin shrdlu</a></li>
<li><a href="Hamburgevons" title="Hamburgevons">Hamburgevons</a></li>
<li><a href="Lorem_ipsum" title="Lorem ipsum">Lorem ipsum</a></li>
<li><a href="The_quick_brown_fox_jumps_over_the_lazy_dog" title="The quick brown fox jumps over the lazy dog">The quick brown fox jumps over the lazy dog</a></li></ul>
</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%">Other</th><td class="navbox-list-with-group navbox-list navbox-even hlist" style="width:100%;padding:0"><div style="padding:0 0.25em">
<ul><li>Acid
<ul><li><a href="Acid1" title="Acid1">1</a></li>
<li><a href="Acid2" title="Acid2">2</a></li>
<li><a href="Acid3" title="Acid3">3</a></li></ul></li>
<li><a href="Bad_Apple!!#Use_of_video_as_a_graphical_and_audio_test" title="Bad Apple!!">"Bad Apple!!"</a></li>
<li><a href="EICAR_test_file" title="EICAR test file">EICAR test file</a></li>
<li><a href="Test_functions_for_optimization" title="Test functions for optimization">Functions for optimization</a></li>
<li><a href="GTUBE" title="GTUBE">GTUBE</a></li>
<li><a href="Harvard_sentences" title="Harvard sentences">Harvard sentences</a></li>
<li><a href="The_North_Wind_and_the_Sun#Use_in_phonetic_demonstrations" title="The North Wind and the Sun">"The North Wind and the Sun"</a></li>
<li><a href="Tom's_Diner#The_&quot;Mother_of_the_MP3&quot;" title="Tom's Diner">"Tom's Diner"</a></li>
<li><a href="Film_leader" title="Film leader">SMPTE universal leader</a></li>
<li><a href="EURion_constellation" title="EURion constellation">EURion constellation</a></li>
<li><a href="Webdriver_Torso" title="Webdriver Torso">Webdriver Torso</a></li>
<li><a href="1951_USAF_resolution_test_chart" title="1951 USAF resolution test chart">1951 USAF resolution test chart</a></li></ul>
</div></td></tr></tbody></table></div></div><!--htdig_noindex--><div><div class="zim-footer">
This article is issued from <a class="external text" title="Last edited on 2025-03-20" href="https://en.wikipedia.org/wiki/?title=Quine_(computing)&amp;oldid=1281382576">Wikipedia</a>. The text is available under <a class="external text" href="https://creativecommons.org/licenses/by-sa/4.0/deed.en">Creative Commons Attribution-Share Alike 4.0</a> unless otherwise noted. Additional terms may apply for the media files.
</div>
</div><!--/htdig_noindex--></div>
</div>
</main>
</div>
</div>
</div>

</body></html>